#include "iic_soft.h"
#include "stdio.h"
#include "sys.h"
//set here to control IIC  SCLK clock
void iic_delay(u8 time)
{
	
	do{
		delay_us(2);
	}while (time--);
	
}
void IIC_Init(IIC_enum IIC_channel)
{
	switch(IIC_channel){
		case IIC0:{
			GPIO_InitTypeDef GPIO_InitStructure;
			RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
			
			GPIO_InitStructure.GPIO_Pin = IIC0_SCL_PIN|IIC0_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
			IIC0_SCL=1;
			IIC0_SDA=1;
			//printf("IIC 0 init \r\n");
		}break;
		case IIC1:{
			GPIO_InitTypeDef GPIO_InitStructure;
			RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
			
			GPIO_InitStructure.GPIO_Pin = IIC1_SCL_PIN|IIC1_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
			IIC1_SCL=1;
			IIC1_SDA=1;
			//printf("IIC 1 init \r\n");
		}break;
		case IIC2:{
			GPIO_InitTypeDef GPIO_InitStructure;
			RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
			
			GPIO_InitStructure.GPIO_Pin = IIC2_SCL_PIN|IIC2_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
			IIC2_SCL=1;
			IIC2_SDA=1;
			//printf("IIC 2 init \r\n");
		}break;
		case IIC3:{
			GPIO_InitTypeDef GPIO_InitStructure;
			RCC_APB2PeriphClockCmd(	RCC_APB2Periph_GPIOB, ENABLE );	
			
			GPIO_InitStructure.GPIO_Pin = IIC3_SCL_PIN|IIC3_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
			IIC3_SCL=1;
			IIC3_SDA=1;
			//printf("IIC 2 init \r\n");
		}break;
		default:break;
	}	     
}

void  SDA_IN(IIC_enum IIC_channel)
{
	switch(IIC_channel){
		case IIC0:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC0_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;   //上拉输入
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		case IIC1:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC1_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;   //上拉输入
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		case IIC2:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC2_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;   //上拉输入
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		case IIC3:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC3_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;   //上拉输入
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		default:break;
	}
}	
void SDA_OUT(IIC_enum IIC_channel) 
{
	switch(IIC_channel){
		case IIC0:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC0_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		case IIC1:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC1_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		case IIC2:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC2_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		case IIC3:{
			GPIO_InitTypeDef GPIO_InitStructure;
			GPIO_InitStructure.GPIO_Pin = IIC3_SDA_PIN;
			GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ;   //推挽输出
			GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
			GPIO_Init(GPIOB, &GPIO_InitStructure);
		}break;
		default:break;
	}
}
//产生IIC起始信号
void IIC_Start(IIC_enum IIC_channel)
{
	switch(IIC_channel){
		case IIC0:{
			SDA_OUT(IIC0);     //sda线输出
			IIC0_SDA=1;	  	  
			IIC0_SCL=1;
			iic_delay(4);
			IIC0_SDA=0;//START:when CLK is high,DATA change form high to low 
			iic_delay(4);
			IIC0_SCL=0;//钳住I2C总线，准备发送或接收数据 
		}break;
		case IIC1:{
			SDA_OUT(IIC1);     //sda线输出
			IIC1_SDA=1;	  	  
			IIC1_SCL=1;
			iic_delay(4);
			IIC1_SDA=0;//START:when CLK is high,DATA change form high to low 
			iic_delay(4);
			IIC1_SCL=0;//钳住I2C总线，准备发送或接收数据 
		}break;
		case IIC2:{
			SDA_OUT(IIC2);     //sda线输出
			IIC2_SDA=1;	  	  
			IIC2_SCL=1;
			iic_delay(4);
			IIC2_SDA=0;//START:when CLK is high,DATA change form high to low 
			iic_delay(4);
			IIC2_SCL=0;//钳住I2C总线，准备发送或接收数据 
		}break;
		case IIC3:{
			SDA_OUT(IIC3);     //sda线输出
			IIC3_SDA=1;	  	  
			IIC3_SCL=1;
			iic_delay(4);
			IIC3_SDA=0;//START:when CLK is high,DATA change form high to low 
			iic_delay(4);
			IIC3_SCL=0;//钳住I2C总线，准备发送或接收数据 
		}break;
		default:break;
	}
}	  
//产生IIC停止信号
void IIC_Stop(IIC_enum IIC_channel)
{
	switch(IIC_channel){
		case IIC0:{
			SDA_OUT(IIC0);//sda线输出
			IIC0_SCL=0;
			IIC0_SDA=0;//STOP:when CLK is high DATA change form low to high
			iic_delay(4);
			IIC0_SCL=1; 
			IIC0_SDA=1;//发送I2C总线结束信号
			iic_delay(4);
		}break;
		case IIC1:{
			SDA_OUT(IIC1);//sda线输出
			IIC1_SCL=0;
			IIC1_SDA=0;//STOP:when CLK is high DATA change form low to high
			iic_delay(4);
			IIC1_SCL=1; 
			IIC1_SDA=1;//发送I2C总线结束信号
			iic_delay(4);
		}break;
		case IIC2:{
			SDA_OUT(IIC2);//sda线输出
			IIC2_SCL=0;
			IIC2_SDA=0;//STOP:when CLK is high DATA change form low to high
			iic_delay(4);
			IIC2_SCL=1; 
			IIC2_SDA=1;//发送I2C总线结束信号
			iic_delay(4);
		}break;
		case IIC3:{
			SDA_OUT(IIC3);//sda线输出
			IIC3_SCL=0;
			IIC3_SDA=0;//STOP:when CLK is high DATA change form low to high
			iic_delay(4);
			IIC3_SCL=1; 
			IIC3_SDA=1;//发送I2C总线结束信号
			iic_delay(4);
		}break;
		default:break;
	}							   	
}
//等待应答信号到来
//返回值：1，接收应答失败
//        0，接收应答成功
u8 IIC_Wait_Ack(IIC_enum IIC_channel)
{
	u8 ucErrTime=0;
	switch(IIC_channel){
		case IIC0:{
			SDA_IN(IIC0);      //SDA设置为输入  
			IIC0_SDA=1;iic_delay(1);	   
			IIC0_SCL=1;iic_delay(1);	 
			while(IIC0_READ_SDA)
			{
				ucErrTime++;
				if(ucErrTime>250)
				{
					IIC_Stop(IIC0);
					return 1;
				}
			}
			IIC0_SCL=0;//时钟输出0 	   
			return 0;  
		}break;
		case IIC1:{
			SDA_IN(IIC1);      //SDA设置为输入  
			IIC1_SDA=1;iic_delay(1);	   
			IIC1_SCL=1;iic_delay(1);	 
			while(IIC1_READ_SDA)
			{
				ucErrTime++;
				if(ucErrTime>250)
				{
					IIC_Stop(IIC1);
					return 1;
				}
			}
			IIC1_SCL=0;//时钟输出0 	   
			return 0;
			
		}break;
		case IIC2:{
			SDA_IN(IIC2);      //SDA设置为输入  
			IIC2_SDA=1;iic_delay(1);	   
			IIC2_SCL=1;iic_delay(1);	 
			while(IIC2_READ_SDA)
			{
				ucErrTime++;
				if(ucErrTime>250)
				{
					IIC_Stop(IIC2);
					return 1;
				}
			}
			IIC2_SCL=0;//时钟输出0 	   
			return 0;
			
		}break;
		case IIC3:{
			SDA_IN(IIC3);      //SDA设置为输入  
			IIC3_SDA=1;iic_delay(1);	   
			IIC3_SCL=1;iic_delay(1);	 
			while(IIC3_READ_SDA)
			{
				ucErrTime++;
				if(ucErrTime>250)
				{
					IIC_Stop(IIC3);
					return 1;
				}
			}
			IIC3_SCL=0;//时钟输出0 	   
			return 0;
			
		}break;
		default:break;
	}		
} 
//产生ACK应答
void IIC_Ack(IIC_enum IIC_channel)
{
	switch(IIC_channel){
		case IIC0:{
			IIC0_SCL=0;
			SDA_OUT(IIC0);
			IIC0_SDA=0;
			iic_delay(2);
			IIC0_SCL=1;
			iic_delay(2);
			IIC0_SCL=0;
		}break;
		case IIC1:{
			IIC1_SCL=0;
			SDA_OUT(IIC1);
			IIC1_SDA=0;
			iic_delay(2);
			IIC1_SCL=1;
			iic_delay(2);
			IIC1_SCL=0;
		}break;
		case IIC2:{
			IIC2_SCL=0;
			SDA_OUT(IIC2);
			IIC2_SDA=0;
			iic_delay(2);
			IIC2_SCL=1;
			iic_delay(2);
			IIC2_SCL=0;
		}break;
		case IIC3:{
			IIC3_SCL=0;
			SDA_OUT(IIC3);
			IIC3_SDA=0;
			iic_delay(2);
			IIC3_SCL=1;
			iic_delay(2);
			IIC3_SCL=0;
		}break;
		default:break;
	}
}
//不产生ACK应答		    
void IIC_NAck(IIC_enum IIC_channel)
{
	switch(IIC_channel){
		case IIC0:{
			IIC0_SCL=0;
			SDA_OUT(IIC0);
			IIC0_SDA=1;
			iic_delay(2);
			IIC0_SCL=1;
			iic_delay(2);
			IIC0_SCL=0;
		}break;
		case IIC1:{
			IIC1_SCL=0;
			SDA_OUT(IIC1);
			IIC1_SDA=1;
			iic_delay(2);
			IIC1_SCL=1;
			iic_delay(2);
			IIC1_SCL=0;
		}break;
		case IIC2:{
			IIC2_SCL=0;
			SDA_OUT(IIC2);
			IIC2_SDA=1;
			iic_delay(2);
			IIC2_SCL=1;
			iic_delay(2);
			IIC2_SCL=0;
		}break;
		case IIC3:{
			IIC3_SCL=0;
			SDA_OUT(IIC3);
			IIC3_SDA=1;
			iic_delay(2);
			IIC3_SCL=1;
			iic_delay(2);
			IIC3_SCL=0;
		}break;
		default:break;
	}

}					 				     
//IIC发送一个字节
//返回从机有无应答
//1，有应答
//0，无应答			  
void IIC_Send_Byte(IIC_enum IIC_channel,u8 txd)
{                        
    u8 t;   
	switch(IIC_channel){
		case IIC0:{
			SDA_OUT(IIC0); 	    
			IIC0_SCL=0;//拉低时钟开始数据传输
			for(t=0;t<8;t++)
			{              
				IIC0_SDA=(txd&0x80)>>7;
				txd<<=1; 	  
				iic_delay(2);   //对TEA5767这三个延时都是必须的
				IIC0_SCL=1;
				iic_delay(2); 
				IIC0_SCL=0;	
				iic_delay(2);
			}	 
		}break;
		case IIC1:{
			SDA_OUT(IIC1); 	    
			IIC1_SCL=0;//拉低时钟开始数据传输
			for(t=0;t<8;t++)
			{              
				IIC1_SDA=(txd&0x80)>>7;
				txd<<=1; 	  
				iic_delay(2);   //对TEA5767这三个延时都是必须的
				IIC1_SCL=1;
				iic_delay(2); 
				IIC1_SCL=0;	
				iic_delay(2);
			}	
		}break;
		case IIC2:{
			SDA_OUT(IIC2); 	    
			IIC2_SCL=0;//拉低时钟开始数据传输
			for(t=0;t<8;t++)
			{              
				IIC2_SDA=(txd&0x80)>>7;
				txd<<=1; 	  
				iic_delay(2);   //对TEA5767这三个延时都是必须的
				IIC2_SCL=1;
				iic_delay(2); 
				IIC2_SCL=0;	
				iic_delay(2);
			}	
		}break;
		case IIC3:{
			SDA_OUT(IIC3); 	    
			IIC3_SCL=0;//拉低时钟开始数据传输
			for(t=0;t<8;t++)
			{              
				IIC3_SDA=(txd&0x80)>>7;
				txd<<=1; 	  
				iic_delay(2);   //对TEA5767这三个延时都是必须的
				IIC3_SCL=1;
				iic_delay(2); 
				IIC3_SCL=0;	
				iic_delay(2);
			}	
		}break;
		default:break;
	}
} 	    
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
u8 IIC_Read_Byte(IIC_enum IIC_channel,u8 ack)
{
	u8 i,receive=0;
	switch(IIC_channel){
		case IIC0:{
			SDA_IN(IIC0);//SDA设置为输入
			for(i=0;i<8;i++ )
			{
				IIC0_SCL=0; 
				iic_delay(2);
				IIC0_SCL=1;
				receive<<=1;
				if(IIC0_READ_SDA)receive++;   
				iic_delay(1); 
			}					 
			if (!ack)
				IIC_NAck(IIC0);//发送nACK
			else
				IIC_Ack(IIC0); //发送ACK   
			return receive;
		}break;
		case IIC1:{
			SDA_IN(IIC1);//SDA设置为输入
			for(i=0;i<8;i++ )
			{
				IIC1_SCL=0; 
				iic_delay(2);
				IIC1_SCL=1;
				receive<<=1;
				if(IIC1_READ_SDA)receive++;   
				iic_delay(1); 
			}					 
			if (!ack)
				IIC_NAck(IIC1);//发送nACK
			else
				IIC_Ack(IIC1); //发送ACK   
			return receive;
		}break;
		case IIC2:{
			SDA_IN(IIC2);//SDA设置为输入
			for(i=0;i<8;i++ )
			{
				IIC2_SCL=0; 
				iic_delay(2);
				IIC2_SCL=1;
				receive<<=1;
				if(IIC2_READ_SDA)receive++;   
				iic_delay(1); 
			}					 
			if (!ack)
				IIC_NAck(IIC2);//发送nACK
			else
				IIC_Ack(IIC2); //发送ACK   
			return receive;
		}break;
		case IIC3:{
			SDA_IN(IIC3);//SDA设置为输入
			for(i=0;i<8;i++ )
			{
				IIC3_SCL=0; 
				iic_delay(2);
				IIC3_SCL=1;
				receive<<=1;
				if(IIC3_READ_SDA)receive++;   
				iic_delay(1); 
			}					 
			if (!ack)
				IIC_NAck(IIC3);//发送nACK
			else
				IIC_Ack(IIC3); //发送ACK   
			return receive;
		}break;
		default:break;
	}
}


/**************************实现函数********************************************
*函数原型:		u8 IICwriteBytes(u8 dev, u8 reg, u8 length, u8* data)
*功　　能:	    将多个字节写入指定设备 指定寄存器
输入	dev  目标设备地址
		reg	  寄存器地址
		length 要写的字节数
		*data  将要写的数据的首地址
返回   返回是否成功
*******************************************************************************/ 
u8 IICwriteBytes(IIC_enum IIC_channel,u8 dev, u8 reg, u8 length, u8* data){
 	u8 count = 0;
	IIC_Start(IIC_channel);
	IIC_Send_Byte(IIC_channel,dev);	   
	IIC_Wait_Ack(IIC_channel);
	IIC_Send_Byte(IIC_channel,reg);   
    IIC_Wait_Ack(IIC_channel);	  
	for(count=0;count<length;count++){
		IIC_Send_Byte(IIC_channel,data[count]); 
		IIC_Wait_Ack(IIC_channel); 
	 }
	IIC_Stop(IIC_channel);

    return 1; //status == 0;
}

/**************************实现函数********************************************
*函数原型:		u8 IICwriteBits(u8 dev,u8 reg,u8 bitStart,u8 length,u8 data)
*功　　能:	    读 修改 写 指定设备 指定寄存器一个字节 中的多个位
输入	dev  目标设备地址
		reg	   寄存器地址
		bitStart  目标字节的起始位
		length   位长度
		data    存放改变目标字节位的值
返回   成功 为1 
 		失败为0
*******************************************************************************/
u8 IICwriteBits(IIC_enum IIC_channel,u8 dev,u8 reg,u8 bitStart,u8 length,u8 data)
{
    u8 b;
    if (IICreadByte(IIC_channel,dev, reg, &b) != 0) {
        u8 mask = (0xFF << (bitStart + 1)) | 0xFF >> ((8 - bitStart) + length - 1);
        data <<= (8 - length);
        data >>= (7 - bitStart);
        b &= mask;
        b |= data;
        return IICwriteByte(IIC_channel,dev, reg, b);
    } else {
        return 0;
    }
}

/**************************实现函数********************************************
*函数原型:		u8 IICwriteBit(u8 dev, u8 reg, u8 bitNum, u8 data)
*功　　能:	    读 修改 写 指定设备 指定寄存器一个字节 中的1个位
输入	dev  目标设备地址
		reg	   寄存器地址
		bitNum  要修改目标字节的bitNum位
		data  为0 时，目标位将被清0 否则将被置位
返回   成功 为1 
 		失败为0
*******************************************************************************/ 
u8 IICwriteBit(IIC_enum IIC_channel,u8 dev, u8 reg, u8 bitNum, u8 data){
    u8 b;
    IICreadByte(IIC_channel,dev, reg, &b);
    b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
    return IICwriteByte(IIC_channel,dev, reg, b);
}

/**************************实现函数********************************************
*函数原型:		u8 IICreadBytes(u8 dev, u8 reg, u8 length, u8 *data)
*功　　能:	    读取指定设备 指定寄存器的 length个值
输入	dev  目标设备地址
		reg	  寄存器地址
		length 要读的字节数
		*data  读出的数据将要存放的指针
返回   读出来的字节数量
*******************************************************************************/
u8 IICreadBytes(IIC_enum IIC_channel,u8 dev, u8 reg, u8 length, u8 *data){
  u8 count = 0;
	IIC_Start(IIC_channel);
	IIC_Send_Byte(IIC_channel,dev);	   
	IIC_Wait_Ack(IIC_channel);
	IIC_Send_Byte(IIC_channel,reg);   
  IIC_Wait_Ack(IIC_channel);	  
	IIC_Start(IIC_channel);
	IIC_Send_Byte(IIC_channel,dev+1);  
	IIC_Wait_Ack(IIC_channel);
	
    for(count=0;count<length;count++){
		 if(count!=length-1)data[count]=IIC_Read_Byte(IIC_channel,1);  
		 	else  data[count]=IIC_Read_Byte(IIC_channel,0);	 
	}
    IIC_Stop(IIC_channel);
    return count;
}

/**************************实现函数********************************************
*函数原型:		u8 IICreadByte(u8 dev, u8 reg, u8 *data)
*功　　能:	    读取指定设备 指定寄存器的一个值
输入	dev  目标设备地址
		reg	   寄存器地址
		*data  读出的数据将要存放的地址
返回   1
*******************************************************************************/
u8 IICreadByte(IIC_enum IIC_channel,u8 dev, u8 reg, u8 *data){
	*data=I2C_ReadOneByte(IIC_channel,dev, reg);
    return 1;
}


/**************************实现函数********************************************
*函数原型:		u8 I2C_ReadOneByte(u8 I2C_Addr,u8 addr)
*功　　能:	    读取指定设备 指定寄存器的一个值
输入	I2C_Addr  目标设备地址
		addr	   寄存器地址
返回   读出来的值
*******************************************************************************/ 
u8 I2C_ReadOneByte(IIC_enum IIC_channel,u8 I2C_Addr,u8 addr)
{
	u8 res=0;
	
	IIC_Start(IIC_channel);	
	IIC_Send_Byte(IIC_channel,I2C_Addr);	   
	res++;
	IIC_Wait_Ack(IIC_channel);
	IIC_Send_Byte(IIC_channel,addr); res++;  
	IIC_Wait_Ack(IIC_channel);	  
	//IIC_Stop();
	IIC_Start(IIC_channel);
	IIC_Send_Byte(IIC_channel,I2C_Addr+1); res++; 	   //send address = read address+1
	IIC_Wait_Ack(IIC_channel);
	res=IIC_Read_Byte(IIC_channel,0);	   
    IIC_Stop(IIC_channel);
	return res;
}

/**************************实现函数********************************************
*函数原型:		u8 IICwriteByte(u8 dev, u8 reg, u8 data)
*功　　能:	    写入指定设备 指定寄存器一个字节
输入	dev  目标设备地址
		reg	   寄存器地址
		data  将要写入的字节
返回   1
*******************************************************************************/
u8 IICwriteByte(IIC_enum IIC_channel,u8 dev, u8 reg, u8 data){
    return IICwriteBytes(IIC_channel,dev, reg, 1, &data);
}


void IIC_SCAN(IIC_enum IIC_channel,u8 dev_add)
{
	
	u8 rx_data[2]={0};
	IIC_Init(IIC_channel);
	printf("===============\r\n");
	printf("IIC Ch: %d   dev id: %#2X\r\n",IIC_channel,dev_add);
	//for(u16 dev_add=0;dev_add<=255;dev_add++)
	//{
	 
		u8 count =0;
		for(u16 reg =0;reg<0x10;reg++)
		{
			count=IICreadBytes(IIC_channel,dev_add<<1, reg, 2,rx_data);
			//if(rx_data[0]!=0){
			printf("dev: %#X  reg: %#X  data: %#X,%#X  \r\n",dev_add,reg,rx_data[0],rx_data[1]);
			//}
		//}
	}
	printf("===============\r\n");
}